#include "main.h"
#include "global_def.h"
#include "InterProtocol.h"
#include "InterComm.h"
#include "api_htbk.h"
#include "api_lcd.h"
#include "api_alarm.h"
#include "includes.h"
#include "pid.h"

#include "api_judge.h"

#include "api_fibocom.h"
#include "at_fibocom_cmd_table.h"
#include "api_esp.h"
#include "api_net_common.h"
#include "movemean.h"
#include "api_net_dataproc.h"

unsigned char UART_TxBuffer[256];
extern uint32_t ADC0_Buffer[ADC0_NUMBER][ADC0_CHANNELS];
uint8_t presend_databuf[2] = {0xFF,0xFF};//升温毯的一些不需要参数的数据值

extern ALARM_PHY_PARM_T alarm_phy_parm;
extern uint16_t Dev_temp_regaddr[11];
extern Equ_Fault_STA_T my_sensor_sta;
extern Equ_Fault_STA_T my_break_sta;
extern Equ_Fault_STA_T my_shorov_sta;
extern Equ_Fault_STA_T my_equoff_sta;
extern Equ_Fault_STA_T my_equoff_itself_sta;
extern Device_Calib_T Device_calib ; //温度校准参数 20220422
//extern uint8_t led_selec_group;//数码管选中哪个组 默认全不选中 20220617
//extern uint8_t led_alarm_group;//无报警显示通道
extern uint8_t Reset_break_sta, Reset_shorov_sta;

extern INTER_BLEInfo_t my_bleinfo;

uint8_t Break_sta = BREAK_NORMAL;//默认热断器正常状态 20220819
uint8_t Shorov_sta = SHOROV_NORMAL;//默认短路或过载正常状态 20220819
uint8_t Dev_stop_flag = false;//自动模式下停止加热的标志位
ALARM_Latch_t alarm_latch = {0,0,false,false};//报警栓锁的参数 如超时

// 滑动平均滤波器(用于去除耳温数据的跳动值)
float fMmovMeanEarTempBuf[10];
Wismed_Movmean_Manager_t movMeanEarTemp = {
    .nBufLen = 10,
    .fMovMeanBuf = fMmovMeanEarTempBuf,
    .fMovMeanDiffBuf = NULL,
};


void AutoMode_temp_set(void);
void pid_debugdata_pack(void);

//unsigned short ADC_EHP_VALUE(unsigned char ch1,unsigned char ch2)
//{
//    uint8_t i = 0;
//    uint32_t chanll1 = 0,chanll2 = 0;
//    for(i = 0;i < ADC0_NUMBER;i++)
//    {
//        chanll1 += ADC0_Buffer[i][ch1];
//        chanll2 += ADC0_Buffer[i][ch2];
//    }
//
//    return ((chanll1/10)+(chanll2/10))/2;
//}
unsigned short ADC_Average_VALUE(unsigned char chanll)
{
    uint8_t i = 0;
    uint32_t chan1 = 0;
    for(i = 0; i < ADC0_NUMBER; i++)
    {
        chan1 += ADC0_Buffer[i][chanll];
    }

    return chan1/10;
}

/**
 * @brief     : 将需要LCD串口发送的数据打包 压入队列
 * @param[in] : void
 * @return    : none
 * @author    : liukaihua
 * @date      : 20220117
 */
//void InterComm_LCD_PackData_all(void)
//{
//		static uint8_t tx_buf[INTER_COMM_LCDCMD_MAX_LEN];
//		uint8_t data_len = INTER_LCDCOMM_HEAD_LEN + LCDCOMM_WRDATA_LEN;
//		uint8_t *data = &tx_buf[INTER_LCDCOMM_HEAD_LEN];
//		INTER_LCDCOMM_HEAD_t *p_head = (INTER_LCDCOMM_HEAD_t *)tx_buf;
//
//		p_head->prefix = 0xA55A;//小端存储方式  0x5AA5;
//		p_head->len = 5;
//		p_head->cmd = INTER_LCD_CMD_WR;
//		for(uint8_t i=0;i<LCD_SEND_PARM_NUM;i++)
//		{
//				p_head->mac_addr[0] = (LCD_PARM_FIRST_ADD+i)>>8 & 0Xff;
//				p_head->mac_addr[1] = (LCD_PARM_FIRST_ADD+i) & 0Xff;
//				memcpy(&data[1], (uint8_t *)(&DeviceDATA) + i*2,1);
//				memcpy(&data[0], (uint8_t *)(&DeviceDATA) + i*2 + 1,1);
//
//				InterComm_tx_Preprocess(INTER_COMM_ADDR_LCD, tx_buf, data_len);
//		}
//}

/**
 * @brief     : crc 和校验
 * @param[in] : void
 * @return    : none
 * @author    : liukaihua
 * @date      : 20220121
 */
uint8_t myCalc_CRC(uint8_t *buf , uint8_t len)
{
    uint8_t my_CRC = 0x00;

    for(uint8_t i; i<len; i++)
    {
        my_CRC = my_CRC + buf[i];
    }
    return my_CRC;
}

/*处理显示当前温度值或者显示- - -*/
void display_temp_now_pro(void)
{
    static Bp_Temp_Islive_t Bp_Temp_Islive_ex = {false, false, false, false, false, false, false, false, false, false};
    static Equ_Fault_STA_T Bp_time_off_ex = {false, false, false, false, false, false, false, false, false, false};
    static uint8_t Ear_connect_sta = false;
    uint8_t data_invalid[2] = {0};//显示 - - -
    uint8_t data_valid[2] = {0,1};//擦除- - -
    uint8_t data[2] = {0};//实际温度数据
    //臂毯1
    if(DeviceConfig.Bp_Temp_Islive.ArmBlanket1 == true)
    {
        if(Bp_Temp_Islive_ex.ArmBlanket1 != DeviceConfig.Bp_Temp_Islive.ArmBlanket1)//存活状态发生变化
            InterComm_LCD_PackData(LCD_HEADW_LEN, ArmBlanket1_TEMP_ISHAVE_DIS, data_valid);
        
        data[0] = (DeviceDATA.Bp_Temp_NowValue.ArmBlanket1 >> 8) & 0xff;
        data[1] = DeviceDATA.Bp_Temp_NowValue.ArmBlanket1 & 0xff;
        InterComm_LCD_PackData(LCD_HEADW_LEN, ArmBlanket1_TEMP_DIS, data);
    }
    else if(DeviceConfig.Bp_Temp_Islive.ArmBlanket1 == false)
    {
        if(Bp_Temp_Islive_ex.ArmBlanket1 != DeviceConfig.Bp_Temp_Islive.ArmBlanket1)//存活状态发生变化
            InterComm_LCD_PackData(LCD_HEADW_LEN, ArmBlanket1_TEMP_ISHAVE_DIS, data_invalid);
    }
    Bp_Temp_Islive_ex.ArmBlanket1 = DeviceConfig.Bp_Temp_Islive.ArmBlanket1;
    //臂毯2
    if(DeviceConfig.Bp_Temp_Islive.ArmBlanket2 == true)
    {
        if(Bp_Temp_Islive_ex.ArmBlanket2 != DeviceConfig.Bp_Temp_Islive.ArmBlanket2)//存活状态发生变化
            InterComm_LCD_PackData(LCD_HEADW_LEN, ArmBlanket2_TEMP_ISHAVE_DIS, data_valid);
        
        data[0] = (DeviceDATA.Bp_Temp_NowValue.ArmBlanket2 >> 8) & 0xff;
        data[1] = DeviceDATA.Bp_Temp_NowValue.ArmBlanket2 & 0xff;
        InterComm_LCD_PackData(LCD_HEADW_LEN, ArmBlanket2_TEMP_DIS, data);
    }
    else if(DeviceConfig.Bp_Temp_Islive.ArmBlanket2 == false)
    {
        if(Bp_Temp_Islive_ex.ArmBlanket2 != DeviceConfig.Bp_Temp_Islive.ArmBlanket2)//存活状态发生变化
            InterComm_LCD_PackData(LCD_HEADW_LEN, ArmBlanket2_TEMP_ISHAVE_DIS, data_invalid);
    }
    Bp_Temp_Islive_ex.ArmBlanket2 = DeviceConfig.Bp_Temp_Islive.ArmBlanket2;
    //脚毯1
    if(DeviceConfig.Bp_Temp_Islive.FT1 == true)
    {
        if(Bp_Temp_Islive_ex.FT1 != DeviceConfig.Bp_Temp_Islive.FT1)//存活状态发生变化
            InterComm_LCD_PackData(LCD_HEADW_LEN, FT1_TEMP_ISHAVE_DIS, data_valid);
        
        data[0] = (DeviceDATA.Bp_Temp_NowValue.FT1 >> 8) & 0xff;
        data[1] = DeviceDATA.Bp_Temp_NowValue.FT1 & 0xff;
        InterComm_LCD_PackData(LCD_HEADW_LEN, FT1_TEMP_DIS, data);
    }
    else if(DeviceConfig.Bp_Temp_Islive.FT1 == false)
    {
        if(Bp_Temp_Islive_ex.FT1 != DeviceConfig.Bp_Temp_Islive.FT1)//存活状态发生变化
            InterComm_LCD_PackData(LCD_HEADW_LEN, FT1_TEMP_ISHAVE_DIS, data_invalid);
    }
    Bp_Temp_Islive_ex.FT1 = DeviceConfig.Bp_Temp_Islive.FT1;
    //脚毯2
    if(DeviceConfig.Bp_Temp_Islive.FT2 == true)
    {
        if(Bp_Temp_Islive_ex.FT2 != DeviceConfig.Bp_Temp_Islive.FT2)//存活状态发生变化
            InterComm_LCD_PackData(LCD_HEADW_LEN, FT2_TEMP_ISHAVE_DIS, data_valid);
        
        data[0] = (DeviceDATA.Bp_Temp_NowValue.FT2 >> 8) & 0xff;
        data[1] = DeviceDATA.Bp_Temp_NowValue.FT2 & 0xff;
        InterComm_LCD_PackData(LCD_HEADW_LEN, FT2_TEMP_DIS, data);
    }
    else if(DeviceConfig.Bp_Temp_Islive.FT2 == false)
    {
        if(Bp_Temp_Islive_ex.FT2 != DeviceConfig.Bp_Temp_Islive.FT2)//存活状态发生变化
            InterComm_LCD_PackData(LCD_HEADW_LEN, FT2_TEMP_ISHAVE_DIS, data_invalid);
    }
    Bp_Temp_Islive_ex.FT2 = DeviceConfig.Bp_Temp_Islive.FT2;
    //上身毯
    if(DeviceConfig.Bp_Temp_Islive.UpperBlanket == true)
    {
        if(Bp_Temp_Islive_ex.UpperBlanket != DeviceConfig.Bp_Temp_Islive.UpperBlanket)//存活状态发生变化
            InterComm_LCD_PackData(LCD_HEADW_LEN, UpperBlanket_TEMP_ISHAVE_DIS, data_valid);
        
        data[0] = (DeviceDATA.Bp_Temp_NowValue.UpperBlanket >> 8) & 0xff;
        data[1] = DeviceDATA.Bp_Temp_NowValue.UpperBlanket & 0xff;
        InterComm_LCD_PackData(LCD_HEADW_LEN, UpperBlanket_TEMP_DIS, data);
    }
    else if(DeviceConfig.Bp_Temp_Islive.UpperBlanket == false)
    {
        if(Bp_Temp_Islive_ex.UpperBlanket != DeviceConfig.Bp_Temp_Islive.UpperBlanket)//存活状态发生变化
            InterComm_LCD_PackData(LCD_HEADW_LEN, UpperBlanket_TEMP_ISHAVE_DIS, data_invalid);
    }
    Bp_Temp_Islive_ex.UpperBlanket = DeviceConfig.Bp_Temp_Islive.UpperBlanket;
    //下身毯
    if(DeviceConfig.Bp_Temp_Islive.LowBlanket == true)
    {
        if(Bp_Temp_Islive_ex.LowBlanket != DeviceConfig.Bp_Temp_Islive.LowBlanket)//存活状态发生变化
            InterComm_LCD_PackData(LCD_HEADW_LEN, LowBlanket_TEMP_ISHAVE_DIS, data_valid);
        
        data[0] = (DeviceDATA.Bp_Temp_NowValue.LowBlanket >> 8) & 0xff;
        data[1] = DeviceDATA.Bp_Temp_NowValue.LowBlanket & 0xff;
        InterComm_LCD_PackData(LCD_HEADW_LEN, LowBlanket_TEMP_DIS, data);
    }
    else if(DeviceConfig.Bp_Temp_Islive.LowBlanket == false)
    {
        if(Bp_Temp_Islive_ex.LowBlanket != DeviceConfig.Bp_Temp_Islive.LowBlanket)//存活状态发生变化
            InterComm_LCD_PackData(LCD_HEADW_LEN, LowBlanket_TEMP_ISHAVE_DIS, data_invalid);
    }
    Bp_Temp_Islive_ex.LowBlanket = DeviceConfig.Bp_Temp_Islive.LowBlanket;
    
    //输液1 加热管盒一直在
    if((DeviceConfig.Bp_Temp_Islive.blood1 == true)&&(my_equoff_itself_sta.blood1 == false))//存活且不脱落
    {
        if((Bp_Temp_Islive_ex.blood1 != DeviceConfig.Bp_Temp_Islive.blood1)||(Bp_time_off_ex.blood1 != my_equoff_itself_sta.blood1))//存活或脱落状态发生变化
            InterComm_LCD_PackData(LCD_HEADW_LEN, BLOOD1_TEMP_ISHAVE_DIS, data_valid);
        
        data[0] = (DeviceDATA.Bp_Temp_NowValue.blood_ch1 >> 8) & 0xff;
        data[1] = DeviceDATA.Bp_Temp_NowValue.blood_ch1 & 0xff;
        InterComm_LCD_PackData(LCD_HEADW_LEN, BLOOD1_TEMP_DIS, data);
    }
    else
    {
        if((Bp_Temp_Islive_ex.blood1 != DeviceConfig.Bp_Temp_Islive.blood1)||(Bp_time_off_ex.blood1 != my_equoff_itself_sta.blood1))//存活状态发生变化
            InterComm_LCD_PackData(LCD_HEADW_LEN, BLOOD1_TEMP_ISHAVE_DIS, data_invalid);
    }
    Bp_Temp_Islive_ex.blood1 = DeviceConfig.Bp_Temp_Islive.blood1;
    Bp_time_off_ex.blood1 = my_equoff_itself_sta.blood1;
    
    //输液2
    if((DeviceConfig.Bp_Temp_Islive.blood2 == true)&&(my_equoff_itself_sta.blood2 == false))//存活且不脱落 外部的脱落判断 (内部脱落判断与存活挂钩 这里不判断)
    {
        if((Bp_Temp_Islive_ex.blood2 != DeviceConfig.Bp_Temp_Islive.blood2)||(Bp_time_off_ex.blood2 != my_equoff_itself_sta.blood2))//存活或脱落状态发生变化
            InterComm_LCD_PackData(LCD_HEADW_LEN, BLOOD2_TEMP_ISHAVE_DIS, data_valid);
        
        data[0] = (DeviceDATA.Bp_Temp_NowValue.blood_ch2 >> 8) & 0xff;
        data[1] = DeviceDATA.Bp_Temp_NowValue.blood_ch2 & 0xff;
        InterComm_LCD_PackData(LCD_HEADW_LEN, BLOOD2_TEMP_DIS, data);
    }
    else
    {
        if((Bp_Temp_Islive_ex.blood2 != DeviceConfig.Bp_Temp_Islive.blood2)||(Bp_time_off_ex.blood2 != my_equoff_itself_sta.blood2))//存活状态发生变化
            InterComm_LCD_PackData(LCD_HEADW_LEN, BLOOD2_TEMP_ISHAVE_DIS, data_invalid);
    }
    Bp_Temp_Islive_ex.blood2 = DeviceConfig.Bp_Temp_Islive.blood2;
    Bp_time_off_ex.blood2 = my_equoff_itself_sta.blood2;

    //加压袋1
    if(DeviceConfig.Bp_Temp_Islive.InfusePress1 == true)
    {
        if(Bp_Temp_Islive_ex.InfusePress1 != DeviceConfig.Bp_Temp_Islive.InfusePress1)//存活状态发生变化
            InterComm_LCD_PackData(LCD_HEADW_LEN, InfusePress1_BP_ISHAVE_DIS, data_valid);
        
        data[0] = (DeviceDATA.Bp_Temp_NowValue.InfusePress1 >> 8) & 0xff;
        data[1] = DeviceDATA.Bp_Temp_NowValue.InfusePress1 & 0xff;
        InterComm_LCD_PackData(LCD_HEADW_LEN, InfusePress1_BP_DIS, data);
    }
    else if(DeviceConfig.Bp_Temp_Islive.InfusePress1 == false)
    {
        if(Bp_Temp_Islive_ex.InfusePress1 != DeviceConfig.Bp_Temp_Islive.InfusePress1)//存活状态发生变化
            InterComm_LCD_PackData(LCD_HEADW_LEN, InfusePress1_BP_ISHAVE_DIS, data_invalid);
    }
    Bp_Temp_Islive_ex.InfusePress1 = DeviceConfig.Bp_Temp_Islive.InfusePress1;
    //加压袋2
    if(DeviceConfig.Bp_Temp_Islive.InfusePress2 == true)
    {
        if(Bp_Temp_Islive_ex.InfusePress2 != DeviceConfig.Bp_Temp_Islive.InfusePress2)//存活状态发生变化
            InterComm_LCD_PackData(LCD_HEADW_LEN, InfusePress2_BP_ISHAVE_DIS, data_valid);
        
        data[0] = (DeviceDATA.Bp_Temp_NowValue.InfusePress2 >> 8) & 0xff;
        data[1] = DeviceDATA.Bp_Temp_NowValue.InfusePress2 & 0xff;
        InterComm_LCD_PackData(LCD_HEADW_LEN, InfusePress2_BP_DIS, data);
    }
    else if(DeviceConfig.Bp_Temp_Islive.InfusePress2 == false)
    {
        if(Bp_Temp_Islive_ex.InfusePress2 != DeviceConfig.Bp_Temp_Islive.InfusePress2)//存活状态发生变化
            InterComm_LCD_PackData(LCD_HEADW_LEN, InfusePress2_BP_ISHAVE_DIS, data_invalid);
    }
    Bp_Temp_Islive_ex.InfusePress2 = DeviceConfig.Bp_Temp_Islive.InfusePress2;
    
    //耳温 若耳温连接 有数据 则发送耳温数据
    if(DeviceDATA.ear_isconnect)
    {
        if(Ear_connect_sta != DeviceDATA.ear_isconnect)//连接状态发生变化
            InterComm_LCD_PackData(LCD_HEADW_LEN, EAR_TEMP_ISHAVE_DIS, data_valid);
        
        data[0] = (DeviceDATA.Bp_Temp_NowValue.ear >> 8) & 0xff;
        data[1] = DeviceDATA.Bp_Temp_NowValue.ear & 0xff;
        InterComm_LCD_PackData(LCD_HEADW_LEN, EAR_TEMP_DIS, data);
    }
    else
    {
        if(Ear_connect_sta != DeviceDATA.ear_isconnect)//连接状态发生变化
            InterComm_LCD_PackData(LCD_HEADW_LEN, EAR_TEMP_ISHAVE_DIS, data_invalid);
    }
    Ear_connect_sta = DeviceDATA.ear_isconnect;
}

//unsigned short debug_adc[10] ={0};
/******************更新设备状态***********************/
void UpDateDeviceStatus(void)
{
   
    /*-------------------打包发送设备的温度信息----------------------*/
//	InterComm_LCD_PackData_group(LCD_HEADW_LEN, 11, Dev_temp_regaddr, &DeviceDATA.Bp_Temp_NowValue.InfusePress1);//加热设备的实时温度
    
    display_temp_now_pro();//显示当前温度值
    
//    InterComm_LCD_PackData_group(LCD_HEADW_LEN, 1, &Dev_temp_regaddr[4], &DeviceDATA.Bp_Temp_NowValue.UpperBlanket);//加热设备的实时温度

//    uint16_t data_tmp =0, data_tmp2 =0;
//    uint8_t data[2];
//    static uint8_t ear_sta_ex = BLE_DISCONNECTED;//耳温连接的前一个状态
//    static uint32_t adc_ehp=0, adc_ft=0, adc_blood1=0, adc_blood2=0, adc_ehp2=0, adc_ft2=0;
//    static uint8_t samp_cnt=0;
//    static uint8_t blood1_offsta_ex = false, blood2_offsta_ex = false, ehp_offsta_ex = false, ft_offsta_ex = false;
////	debug_adc[0] = ADC_Average_VALUE(0);
////	debug_adc[1] = ADC_Average_VALUE(1);
////	debug_adc[2] = ADC_Average_VALUE(2);
////	debug_adc[3] = ADC_Average_VALUE(3);
////	debug_adc[4] = ADC_Average_VALUE(4);
////	debug_adc[5] = ADC_Average_VALUE(5);
////	debug_adc[6] = ADC_Average_VALUE(6);
////	debug_adc[7] = ADC_Average_VALUE(7);
////	debug_adc[8] = ADC_Average_VALUE(8);
////	debug_adc[9] = ADC_Average_VALUE(9);
//    adc_ehp += ADC_Average_VALUE(ADC_EHP_CHANNEL);//(0);
//    adc_ft += ADC_Average_VALUE(ADC_FT_CHANNEL);//(4);
//    adc_blood1 += ADC_Average_VALUE(ADC_BLOOD1_CHANNEL);//(2);
//    adc_blood2 += ADC_Average_VALUE(ADC_BLOOD2_CHANNEL);//(3);
//    adc_ehp2 += ADC_Average_VALUE(ADC_EHP2_CHANNEL);//第2个热敏电阻通道
//    adc_ft2 += ADC_Average_VALUE(ADC_FT2_CHANNEL);//足温第2路 20220622
//    samp_cnt++;
//    if(samp_cnt >=20)//100ms *20次 = 2秒
//    {
//        samp_cnt =0;
//        adc_ehp = adc_ehp / 20;
//        adc_ehp2 = adc_ehp2 / 20;
//        adc_ft = adc_ft / 20;
//        adc_ft2 = adc_ft2 / 20;
//        adc_blood1 = adc_blood1 / 20;
//        adc_blood2 = adc_blood2 / 20;

//        /***************采集计算电热垫温度**************/
//        if((adc_ehp < 4000)||(adc_ehp2 < 4000))//两路温差能达到2-3度 读一路到40度有可能触发热断器报警     if(adc_ehp2 < 4000)//20221108改成只测一个热敏电阻值
//        {
//            if(adc_ehp < 4000)//未到3.3V 即认为接入了传感器
//                data_tmp = Get_Tempture_50k_ehp(adc_ehp);//(ADC_Average_VALUE(0));
//            if(adc_ehp2 < 4000)//未到3.3V 即认为接入了传感器
//                data_tmp2 = Get_Tempture_50k_ehp(adc_ehp2);//(ADC_Average_VALUE(0));
////            data_tmp = Get_Tempture_50k_ehp(adc_ehp2);

//            if((data_tmp2 > data_tmp)&&(data_tmp2 < 1000))//取温度较大者 对于极低ad值会计算出400度的高温？？？
//                data_tmp = data_tmp2;

//            data_tmp = data_tmp + Device_calib.ehp; //温度补偿
//            my_sensor_sta.ehp = false;

//            //去除首次插上加热设备 出现显示错误值的问题
//            if(ehp_offsta_ex == true)
//            {
//                ehp_offsta_ex = false;
//                data_tmp = TEMP_NONE;//刚连接上 数据有可能错误 不显示
//            }
//        }
//        else
//        {
//            data_tmp = TEMP_NONE;//不连接 温度无效 显示---         0;//若未接入传感器 显示0 后面要考虑显示- - - ？
//            if((DeviceConfig.SYS_CONTRL == DEVICE_BEGIN)&&(DeviceConfig.Device_EHP_RUN_CONTRL == DEVICE_BEGIN) && (DeviceConfig.ehp_run_sta == DEVICE_BEGIN))//设备运行后才报警传感器脱落
//            {
//                if(EquOffsta_get(EHP_channel))//设备脱落不报传感器故障
//                    my_sensor_sta.ehp = false;
//                else
//                    my_sensor_sta.ehp = true;
//            }
//            else
//                my_sensor_sta.ehp = false;//20220809不运行 不报警传感器故障或脱落
//        }
//        if(EquOffsta_get(EHP_channel))//设备脱落
//        {
//            data_tmp = TEMP_NONE;//不连接 温度无效 显示---
//            ehp_offsta_ex = true;
//        }

//        DeviceDATA.ehp_temp_now = data_tmp;// //获取加热垫温度
////		if((led_selec_group != EHP_SELEC)&&(led_alarm_group != EHP_SELEC))//旋钮没选中此路闪烁再正常显示 并且无报警显示
////		{
////			if(data_tmp == TEMP_NONE)//温度无效 显示---
////				LED_PackData_group(DeviceDATA.ehp_temp_now, LED_EHP_CMD, LED_DIS_BAR);
////			else
////				LED_PackData_group(DeviceDATA.ehp_temp_now, LED_EHP_CMD, LED_DIS_NUM);
////		}

//        /***************采集计算足温垫温度*************/
//        data_tmp =0;
//        data_tmp2 =0;
//        if((adc_ft < 4000)||(adc_ft2 < 4000))//20220622  if(adc_ft < 4000)
//        {
//            if(adc_ft < 4000)
//                data_tmp = Get_Tempture_50k_ft(adc_ft);//(ADC_Average_VALUE(4));//(6));         //获取足部温度
//            if(adc_ft2 < 4000)
//                data_tmp2 = Get_Tempture_50k_ft(adc_ft2);

//            if((data_tmp2 > data_tmp)&&(data_tmp2 < 1000))
//                data_tmp = data_tmp2;

//            data_tmp = data_tmp + Device_calib.ft;//温度补偿
//            my_sensor_sta.ft = false;

//            //去除首次插上加热设备 出现显示错误值的问题
//            if(ft_offsta_ex == true)
//            {
//                ft_offsta_ex = false;
//                data_tmp = TEMP_NONE;//刚连接上 数据有可能错误 不显示
//            }
//        }
//        else
//        {
//            data_tmp = TEMP_NONE;//不连接 温度无效 显示---         0;
//            if((DeviceConfig.SYS_CONTRL == DEVICE_BEGIN)&&(DeviceConfig.Device_FT_RUN_CONTRL == DEVICE_BEGIN) && (DeviceConfig.ft_run_sta == DEVICE_BEGIN))//设备运行后才报警传感器脱落
//            {
//                if(EquOffsta_get(FT1_channel))//设备脱落不报传感器故障
//                    my_sensor_sta.ft = false;
//                else
//                    my_sensor_sta.ft = true;
//            }
//            else
//                my_sensor_sta.ft = false;//20220809不运行 不报警传感器故障或脱落
//        }
//        //20221105关闭测试用
//        if(EquOffsta_get(FT1_channel))//设备脱落
//        {
//            data_tmp = TEMP_NONE;//不连接 温度无效 显示---
//            ft_offsta_ex = true;
//        }

//        DeviceDATA.ft_temp_now = data_tmp;
////		if((led_selec_group != FT_SELEC)&&(led_alarm_group != FT_SELEC))//旋钮没选中此路闪烁再正常显示 并且无报警显示
////		{
////			if(data_tmp == TEMP_NONE)//温度无效 显示---
////				LED_PackData_group(DeviceDATA.ft_temp_now, LED_FT_CMD, LED_DIS_BAR);
////			else
////				LED_PackData_group(DeviceDATA.ft_temp_now, LED_FT_CMD, LED_DIS_NUM);
////		}

//        /***************采集计算加热管1温度*************/
//        data_tmp =0;
//        data_tmp2 =0;
//        if(adc_blood1 < 4000)
//        {
//            data_tmp = Get_Tempture_10k(adc_blood1);//(ADC_Average_VALUE(2));//(1));// ADC_EHP_VALUE(1,4);                  //获取输血输液CH1温度
//            data_tmp = data_tmp + Device_calib.blood1;//暂时用低温校准表示加热管1  Device_calib.blood_h;

//            my_sensor_sta.blood1 = false;

//            //去除首次插上加热设备 出现显示错误值的问题
//            if(blood1_offsta_ex == true)
//            {
//                blood1_offsta_ex = false;
//                data_tmp = TEMP_NONE;//刚连接上 数据有可能错误 不显示
//            }
//        }
//        else
//        {
//            data_tmp = TEMP_NONE;//不连接 温度无效 显示---         0;
//            if((DeviceConfig.SYS_CONTRL == DEVICE_BEGIN)&&(DeviceConfig.Device_BLOODCH1_RUN_CONTRL == DEVICE_BEGIN) && (DeviceConfig.blood1_run_sta == DEVICE_BEGIN))//设备运行后才报警传感器脱落
//            {
//                if(EquOffsta_get(BLOOD1_channel))//设备脱落不报传感器故障
//                    my_sensor_sta.blood1 = false;
//                else
//                    my_sensor_sta.blood1 = true;
//            }
//            else
//                my_sensor_sta.blood1 = false;//20220809不运行 不报警传感器故障或脱落
//        }
//        if(EquOffsta_get(BLOOD1_channel))//设备脱落
//        {
//            data_tmp = TEMP_NONE;//不连接 温度无效 显示---
//            blood1_offsta_ex = true;
//        }

//        DeviceDATA.blood_ch1_temp_now = data_tmp;
////		if((led_selec_group != BLOOD1_SELEC)&&(led_alarm_group != BLOOD1_SELEC))//旋钮没选中此路闪烁再正常显示 并且无报警显示
////		{
////			if(data_tmp == TEMP_NONE)//温度无效 显示---
////				LED_PackData_group(DeviceDATA.blood_ch1_temp_now, LED_BLOOD1_CMD, LED_DIS_BAR);
////			else
////				LED_PackData_group(DeviceDATA.blood_ch1_temp_now, LED_BLOOD1_CMD, LED_DIS_NUM);
////		}

//        /***************采集计算加热管2温度*************/
//        data_tmp =0;
//        data_tmp2 =0;
//        if(adc_blood2 < 4000)
//        {
//            data_tmp = Get_Tempture_10k(adc_blood2);//(ADC_Average_VALUE(3));//(0));// ADC_EHP_VALUE(0,5);                  //获取输血输液CH2温度
//            data_tmp = data_tmp + Device_calib.blood2;

//            my_sensor_sta.blood2 = false;

//            //去除首次插上加热设备 出现显示错误值的问题
//            if(blood2_offsta_ex == true)
//            {
//                blood2_offsta_ex = false;
//                data_tmp = TEMP_NONE;//刚连接上 数据有可能错误 不显示
//            }
//        }
//        else
//        {
//            data_tmp = TEMP_NONE;//不连接 温度无效 显示---         0;
//            if((DeviceConfig.SYS_CONTRL == DEVICE_BEGIN)&&(DeviceConfig.Device_BLOODCH2_RUN_CONTRL == DEVICE_BEGIN) && (DeviceConfig.blood2_run_sta == DEVICE_BEGIN))//设备运行后才报警传感器脱落
//            {
//                if(EquOffsta_get(BLOOD2_channel))//设备脱落不报传感器故障
//                    my_sensor_sta.blood2 = false;
//                else
//                    my_sensor_sta.blood2 = true;
//            }
//            else
//                my_sensor_sta.blood2 = false;//20220809不运行 不报警传感器故障或脱落
//        }
//        if(EquOffsta_get(BLOOD2_channel))//设备脱落
//        {
//            data_tmp = TEMP_NONE;//不连接 温度无效 显示---
//            blood2_offsta_ex = true;
//        }

//        DeviceDATA.blood_ch2_temp_now = data_tmp;

//        adc_ehp = 0;
//        adc_ehp2 = 0;
//        adc_ft = 0;
//        adc_ft2 = 0;
//        adc_blood1 = 0;
//        adc_blood2 = 0;
//    }
}

/**
 * @brief     : 加热垫的温度自动控制
 * @param[in] : void
 * @return    : none
 * @author    : liukaihua
 * @date      : 20220121
 */
//void EHP_temp_con(void)
//{
//		/*加热垫控制*/
//		if(DeviceDATA.ehp_temp_now >= (DeviceDATA.ehp_temp_set + 5))//+5是0.5度  加热垫的现在温度大于设置温度 +1
//		{
//				EHP_CONTRL_OFF;//关闭加热垫
//		}
//		else if(DeviceDATA.ehp_temp_now <= (DeviceDATA.ehp_temp_set - 5))//加热垫现在的温度低于设置温度-1
//		{
//				EHP_CONTRL_ON;//打开加热垫
//		}
//}

/**
 * @brief     : 足温垫的温度自动控制
 * @param[in] : void
 * @return    : none
 * @author    : liukaihua
 * @date      : 20220121
 */
//void FT_temp_con(void)
//{
//		/*足温垫控制*/
//		if(DeviceDATA.ft_temp_now >= (DeviceDATA.ft_temp_set + 5))//足温垫的现在温度大于设置温度 +1
//		{
//				FT_CONTRL_OFF;//关闭足温垫
//		}
//		else if(DeviceDATA.ft_temp_now <= (DeviceDATA.ft_temp_set - 5))//足温垫现在的温度低于设置温度-1
//		{
//				FT_CONTRL_ON;//打开足温垫
//		}
//}

/**
 * @brief     : 输液器1、2的温度自动控制
 * @param[in] : void
 * @return    : none
 * @author    : liukaihua
 * @date      : 20220121
 */
//void BLOOD1_temp_con(void)
//{
//		/*输液1控制*/
//		if(DeviceDATA.blood_ch1_temp_now >= (DeviceDATA.blood_ch1_temp_set + 5))//输液1的现在温度大于设置温度 +1
//		{
//				BLOOD_CH1_CONTRL_OFF;//关闭
//		}
//		else if(DeviceDATA.blood_ch1_temp_now <= (DeviceDATA.blood_ch1_temp_set - 5))//输液1现在的温度低于设置温度-1
//		{
//				BLOOD_CH1_CONTRL_ON;//打开
//		}
//}
//void BLOOD2_temp_con(void)
//{
//		/*输液2控制*/
//		if(DeviceDATA.blood_ch2_temp_now >= (DeviceDATA.blood_ch2_temp_set + 5))//输液2的现在温度大于设置温度 +1
//		{
//				BLOOD_CH2_CONTRL_OFF;//关闭
//		}
//		else if(DeviceDATA.blood_ch2_temp_now <= (DeviceDATA.blood_ch2_temp_set - 5))//输液2现在的温度低于设置温度-1
//		{
//				BLOOD_CH2_CONTRL_ON;//打开
//		}
//}

/**
 * @brief     : 升温毯的温度自动控制 通信指令待完善？
 * @param[in] : void
 * @return    : none
 * @author    : liukaihua
 * @date      : 20220121
 */
//void HP_temp_con(void)
//{
//		/*升温毯控制*/
//		if(DeviceDATA.hp_temp_now >= (DeviceDATA.hp_temp_set + 5))//升温毯的现在温度大于设置温度 +1
//		{
//				htbk_heat_off();//关闭升温毯 电热丝
//		}
//		else if(DeviceDATA.hp_temp_now <= (DeviceDATA.hp_temp_set - 5))//升温毯现在的温度低于设置温度-1
//		{
//				htbk_heat_on();//打开升温毯 电热丝
//		}
//}

/**
 * @brief     : 对温度进行自动控制 控制的温度范围根据标准或者后面调试再定
 * @param[in] : void
 * @return    : none
 * @author    : liukaihua
 * @date      : 20220121
 */
//void AUTO_TEMP_CONTRL(void)
//{
//    if(DeviceConfig.SYS_CONTRL == DEVICE_BEGIN)//系统开始运行后进行温度调控
//    {
////				if(DeviceConfig.Device_EHP_RUN_CONTRL == DEVICE_BEGIN)//加热垫的运行控制 开始
////				{
////						EHP_temp_con();
////				}
////				if(DeviceConfig.Device_FT_RUN_CONTRL == DEVICE_BEGIN)//足温垫的运行控制 开始
////				{
////						FT_temp_con();
////				}
////				if(DeviceConfig.Device_BLOODCH1_RUN_CONTRL == DEVICE_BEGIN)//输液器1加热的运行控制 开始
////				{
////						BLOOD1_temp_con();
////				}
////				if(DeviceConfig.Device_BLOODCH2_RUN_CONTRL == DEVICE_BEGIN)//输液器1加热的运行控制 开始
////				{
////						BLOOD2_temp_con();
////				}
////				if(DeviceConfig.Device_HP_RUN_CONTRL == DEVICE_BEGIN)//升温毯的运行控制 开始
////				{
////						HP_temp_con();
////				}
//        if((DeviceDATA.ear_isconnect)&&(DeviceDATA.ear_temp_now >= alarm_phy_parm.ear_h))//耳温连接 且 人体温度大于设定的报警稳定停止运行 此处待定？
//        {
//            DeviceConfig.SYS_CONTRL = DEVICE_STOP;
//            Other_sys_con();//非lcd 其他的系统控制
//        }
//    }
//}

/**
 * @brief     : 对断路器状态进行判断 每2秒判断一次
 * @param[in] : void
 * @return    : none
 * @author    : liukaihua
 * @date      : 20220325
 */
unsigned short dbg_data_tmp, dbg_data_tmp2;
//void equ_read_break(void)
//{
//    unsigned short data_tmp, data_tmp2;
//    uint8_t data_lcd[2]= {0};
////    static uint8_t ehp_break_sta_flag = false, ft_break_sta_flag = false, blood1_break_sta_flag = false, blood2_break_sta_flag = false;
////		static uint16_t break_sta_cnt=0;
//    uint8_t Pehp_break_sta = true, Pft_break_sta = true, Pblood1_break_sta = true, Pblood2_break_sta = true;//每次调用先赋值机械热断器报警态 20220925

//    /*************************************电热垫热断器判断******************************************/
////	if((DeviceConfig.SYS_CONTRL == DEVICE_BEGIN)&&(DeviceConfig.Device_EHP_RUN_CONTRL == DEVICE_BEGIN) &&(DeviceConfig.ehp_run_sta == DEVICE_BEGIN))
////    if(Break_sta != BREAK_RESET_START)//只要是非热断器复位过程中 都要读报警状态
//    if((Break_sta != BREAK_RESET_START)&&((alarm_latch.break_timeout == 0)||(my_break_sta.ehp == false)))// 非复位过程中且不栓锁过程中 读报警状态
//    {
////				data_tmp = ADC_Average_VALUE(ADC_EHP_BREAK_CHANNEL);//(6); //读取电热垫的断路器检测ad值
////////		if(data_tmp >4000) //读取ad为3.3V高电平
////				if(data_tmp > 248)//有pwm，不能用高电平判断 需要采集ad值计算   0.2V对应ad值248
////					Pehp_break_sta = false; //正常工作状态
////				else if(pid_parm_ehp.Out == EHP_PWMDUTY_NULL)//若小于上面的ad值 但是pwm设置的输出端的占空比是0 也正常工作
////					Pehp_break_sta = false; //正常工作状态

////				if((RDQsta_get(EHP_channel))&&(Pehp_break_sta == false))//读取高电平正常 且读取的机械热断器也正常
//        if(RDQsta_get(EHP_channel))//20221109 由于电热垫电阻丝不同型号差异大 这里不再读取机械热断器报警
//        {
//            my_break_sta.ehp = false; //正常工作状态
//            if((DeviceConfig.ehp_run_sta == DEVICE_STOP)&&(my_shorov_sta.ehp == false)&&(Dev_stop_flag == false))//若之前是此设备发生了热断器报警且关闭 且无短路报警 且若自动模式运行状态 则需要打开运行
//            {
//                DeviceConfig.ehp_run_sta = DEVICE_BEGIN;
//                LCD_ehp_con();
//            }
//            my_break_sta.ehp_cnt =0;//清空热断器持续判断累计
//        }
//        else//低电平报警
//        {
//            my_break_sta.ehp_cnt++;
//            if(my_break_sta.ehp_cnt >= BREAK_CNT_TIMEOUT)//持续10秒后再报警
//            {
//                my_break_sta.ehp = true; //断路器断开状态
//                my_break_sta.ehp_cnt =0;//清空热断器持续判断累计
//            }
////            ehp_break_sta_flag = true;
//        }
//    }
//    else
//        my_break_sta.ehp_cnt =0;//清空热断器持续判断累计
////	else
////		my_break_sta.ehp = false; //正常工作状态
//    //做报警栓塞 一旦热断器报警 就保持报警 停止设备运行 待设备重新运行再去判断报警状态
////    if((my_break_sta.ehp == true)&&(ehp_break_sta_flag == true))
//    if((my_break_sta.ehp == true)&&(DeviceConfig.ehp_run_sta == DEVICE_BEGIN))//20220924
//    {
////		DeviceConfig.Device_EHP_RUN_CONTRL = DEVICE_STOP ;
//        DeviceConfig.ehp_run_sta = DEVICE_STOP;
//        LCD_ehp_con();
////        ehp_break_sta_flag = false;
//    }

//    /*************************************足温垫热断器判断******************************************/
////	if((DeviceConfig.SYS_CONTRL == DEVICE_BEGIN)&&(DeviceConfig.Device_FT_RUN_CONTRL == DEVICE_BEGIN) &&(DeviceConfig.ft_run_sta == DEVICE_BEGIN))
////    if(Break_sta != BREAK_RESET_START)//只要是非热断器复位过程中 都要读报警状态
//    if((Break_sta != BREAK_RESET_START)&&((alarm_latch.break_timeout == 0)||(my_break_sta.ft == false)))// 非复位过程中且不栓锁过程中 读报警状态
//    {
//        /*        data_tmp = ADC_Average_VALUE(ADC_FT_BREAK_CHANNEL);//(9); //读取足温垫的断路器检测ad值
//                data_tmp2 = ADC_Average_VALUE(ADC_FT2_BREAK_CHANNEL);
//        		dbg_data_tmp= data_tmp;
//        		dbg_data_tmp2= data_tmp2;
//                //248为6%占空比左右 计算方式3.3V 即4096 对应100%占空比
//        //        if( ((data_tmp > 248)||(pid_parm_ft.Out == FT_PWMDUTY_NULL)) && ((data_tmp2 > 248)||(pid_parm_ft2.Out == FT2_PWMDUTY_NULL)) )//有pwm，不能用高电平判断 需要采集ad值计算   0.2V对应ad值248

//                //pwm低于10%占空比 无法判断机械热断器 认为正常 下面有持续10秒判断可以保证出错（即必须连续10秒 高于10%占空比输出 且采集的ad小于6%的占空比 则热断器报警）
//                if( ((data_tmp > 248)||(pid_parm_ft.Out <= FT_PWMDUTY_DOWN)) && ((data_tmp2 > 248)||(pid_parm_ft2.Out <= FT2_PWMDUTY_DOWN)) )
//                    Pft_break_sta = false; //正常工作状态
//        //				else if(pid_parm_ft.Out == FT_PWMDUTY_UPPER)//若小于上面的ad值 但是pwm设置的输出端的占空比是0 也正常工作
//        //					my_break_sta.ft = false; //正常工作状态

//                if((RDQsta_get(FT1_channel)) && (RDQsta_get(FT2_channel)) && (Pft_break_sta == false))//读取高电平正常*/
//        if((RDQsta_get(FT1_channel)) && (RDQsta_get(FT2_channel)) )//读取高电平正常
//        {
//            my_break_sta.ft = false; //正常工作状态
//            if((DeviceConfig.ft_run_sta == DEVICE_STOP)&&(my_shorov_sta.ft == false)&&(Dev_stop_flag == false))//若之前是此设备发生了热断器报警且关闭 且无短路报警 则需要打开运行
//            {
//                DeviceConfig.ft_run_sta = DEVICE_BEGIN;
//                LCD_ft_con();
//            }
//            my_break_sta.ft_cnt =0;//清空热断器持续判断累计
//        }
//        else//低电平报警
//        {
//            my_break_sta.ft_cnt++;
//            if(my_break_sta.ft_cnt >= BREAK_CNT_TIMEOUT)//持续10秒后再报警
//            {
//                my_break_sta.ft = true; //断路器断开状态
//                my_break_sta.ft_cnt =0;//清空热断器持续判断累计
//            }
////            ft_break_sta_flag = true;
//        }
//    }
//    else
//        my_break_sta.ft_cnt =0;//清空热断器持续判断累计
////	else
////		my_break_sta.ft = false; //正常工作状态
//    //做报警栓塞 一旦热断器报警 就保持报警 停止设备运行 待设备重新运行再去判断报警状态
////    if((my_break_sta.ft == true)&&(ft_break_sta_flag == true))
//    if((my_break_sta.ft == true)&&(DeviceConfig.ft_run_sta == DEVICE_BEGIN))//20220924
//    {
////		DeviceConfig.Device_FT_RUN_CONTRL = DEVICE_STOP ;
//        DeviceConfig.ft_run_sta = DEVICE_STOP;
//        LCD_ft_con();
////        ft_break_sta_flag = false;
//    }

//    /*************************************加热管1热断器判断******************************************/
////	if((DeviceConfig.SYS_CONTRL == DEVICE_BEGIN)&&(DeviceConfig.Device_BLOODCH1_RUN_CONTRL == DEVICE_BEGIN) &&(DeviceConfig.blood1_run_sta == DEVICE_BEGIN))
////    if(Break_sta != BREAK_RESET_START)//只要是非热断器复位过程中 都要读报警状态
//    if((Break_sta != BREAK_RESET_START)&&((alarm_latch.break_timeout == 0)||(my_break_sta.blood1 == false)))// 非复位过程中且不栓锁过程中 读报警状态
//    {
////				data_tmp = ADC_Average_VALUE(ADC_BLOOD1_BREAK_CHANNEL);//(7); //读取输液1的断路器检测ad值
////////		if(data_tmp >4000) //读取ad为3.3V高电平
////////		data_tmp =300;//test
////				if(data_tmp > 248)//有pwm，不能用高电平判断 需要采集ad值计算   0.2V对应ad值248
////					Pblood1_break_sta = false; //正常工作状态
////				else if(pid_parm_blood1.Out == BLOOD_PWMDUTY_NULL)//若小于上面的ad值 但是pwm设置的输出端的占空比是0 也正常工作
////					Pblood1_break_sta = false; //正常工作状态

////        if((RDQsta_get(BLOOD1_channel)) && (Pblood1_break_sta == false))//读取高电平正常
//        if(RDQsta_get(BLOOD1_channel))//20220927 加温管硬件无机械热断器 不读
//        {
//            my_break_sta.blood1 = false; //正常工作状态
//            if((DeviceConfig.blood1_run_sta == DEVICE_STOP)&&(my_shorov_sta.blood1 == false)&&(Dev_stop_flag == false))//若之前是此设备发生了热断器报警且关闭 且无短路报警 则需要打开运行
//            {
//                DeviceConfig.blood1_run_sta = DEVICE_BEGIN;
//                LCD_blood1_con();
//            }
//            my_break_sta.blood1_cnt =0;//清空热断器持续判断累计
//        }
//        else//低电平报警
//        {
//            my_break_sta.blood1_cnt++;
//            if(my_break_sta.blood1_cnt >= BREAK_CNT_TIMEOUT)//持续10秒后再报警
//            {
//                my_break_sta.blood1 = true; //断路器断开状态
//                my_break_sta.blood1_cnt =0;//清空热断器持续判断累计
//            }
////            blood1_break_sta_flag = true;
//        }
//    }
//    else
//        my_break_sta.blood1_cnt =0;//清空热断器持续判断累计
////	else
////		my_break_sta.blood1 = false; //正常工作状态
//    //做报警栓塞 一旦热断器报警 就保持报警 停止设备运行 待设备重新运行再去判断报警状态
////    if((my_break_sta.blood1 == true)&&(blood1_break_sta_flag == true))
//    if((my_break_sta.blood1 == true)&&(DeviceConfig.blood1_run_sta == DEVICE_BEGIN))//20220924
//    {
////		DeviceConfig.Device_BLOODCH1_RUN_CONTRL = DEVICE_STOP ;
//        DeviceConfig.blood1_run_sta = DEVICE_STOP;
//        LCD_blood1_con();
////        blood1_break_sta_flag = false;
//    }

//    /*************************************加热管2热断器判断******************************************/
////	if((DeviceConfig.SYS_CONTRL == DEVICE_BEGIN)&&(DeviceConfig.Device_BLOODCH2_RUN_CONTRL == DEVICE_BEGIN) && (DeviceConfig.blood2_run_sta == DEVICE_BEGIN))
////    if(Break_sta != BREAK_RESET_START)//只要是非热断器复位过程中 都要读报警状态
//    if((Break_sta != BREAK_RESET_START)&&((alarm_latch.break_timeout == 0)||(my_break_sta.blood2 == false)))// 非复位过程中且不栓锁过程中 读报警状态
//    {
////				data_tmp = ADC_Average_VALUE(ADC_BLOOD2_BREAK_CHANNEL);//(8); //读取输液2的断路器检测ad值
////////		if(data_tmp >4000) //读取ad为3.3V高电平
////				if(data_tmp > 248)//有pwm，不能用高电平判断 需要采集ad值计算   0.2V对应ad值248
////					Pblood2_break_sta = false; //正常工作状态
////				else if(pid_parm_blood2.Out == BLOOD_PWMDUTY_NULL)//若小于上面的ad值 但是pwm设置的输出端的占空比是0 也正常工作
////					Pblood2_break_sta = false; //正常工作状态

////        if((RDQsta_get(BLOOD2_channel)) && (Pblood2_break_sta == false))//读取高电平正常
//        if(RDQsta_get(BLOOD2_channel))//20220927 加温管硬件无机械热断器 不读
//        {
//            my_break_sta.blood2 = false; //正常工作状态
//            if((DeviceConfig.blood2_run_sta == DEVICE_STOP)&&(my_shorov_sta.blood2 == false)&&(Dev_stop_flag == false))//若之前是此设备发生了热断器报警且关闭 且无短路报警 则需要打开运行
//            {
//                DeviceConfig.blood2_run_sta = DEVICE_BEGIN;
//                LCD_blood2_con();
//            }
//            my_break_sta.blood2_cnt =0;//清空热断器持续判断累计
//        }
//        else//低电平报警
//        {
//            my_break_sta.blood2_cnt++;
//            if(my_break_sta.blood2_cnt >= BREAK_CNT_TIMEOUT)//持续10秒后再报警
//            {
//                my_break_sta.blood2 = true; //断路器断开状态
//                my_break_sta.blood2_cnt =0;//清空热断器持续判断累计
//            }
////            blood2_break_sta_flag = true;
//        }
//    }
//    else
//        my_break_sta.blood2_cnt =0;//清空热断器持续判断累计
////	else
////		my_break_sta.blood2 = false; //正常工作状态
//    //做报警栓塞 一旦热断器报警 就保持报警 停止设备运行 待设备重新运行再去判断报警状态
////    if((my_break_sta.blood2 == true)&&(blood2_break_sta_flag == true))
//    if((my_break_sta.blood2 == true)&&(DeviceConfig.blood2_run_sta == DEVICE_BEGIN))//20220924
//    {
////		DeviceConfig.Device_BLOODCH2_RUN_CONTRL = DEVICE_STOP ;
//        DeviceConfig.blood2_run_sta = DEVICE_STOP;
//        LCD_blood2_con();
////        blood2_break_sta_flag = false;
//    }

//    /*********************************************对热断器进行复位操作20220819新需求 不能一直栓锁******************************************/
//    switch(Break_sta)
//    {
//    case BREAK_NORMAL://热断器正常状态
//        if((my_break_sta.ehp == true)||(my_break_sta.ft == true)||(my_break_sta.blood1 == true)||(my_break_sta.blood2 == true))//若有热断器报警栓锁 触发复位 解除栓锁
//        {
//            alarm_latch.break_timeout++;
//            if(alarm_latch.break_timeout >= BREAK_TIMEOUT)//1min   热断器报警发生 栓锁10分钟后再复位  20220924
//            {
//                gpio_bit_set(RESET_RDQBJ_GPIO_PORT, RESET_RDQBJ_PIN);//开机热断器复位 高电平复位
//                Break_sta = BREAK_RESET_START;
//                alarm_latch.break_timeout = 0;
//            }
//        }
//        else
//        {
//            alarm_latch.break_timeout = 0;
//        }
//        break;
//    case BREAK_RESET_START://热断器复位开始状态
//        gpio_bit_reset(RESET_RDQBJ_GPIO_PORT, RESET_RDQBJ_PIN);
//        Break_sta = BREAK_RESET_END;
//        break;
//    case BREAK_RESET_END://热断器复位结束状态
//        Break_sta = BREAK_NORMAL;
//        break;
//    default:
//        break;
//    }
//    if(alarm_latch.break_reset_flag == true)//系统重启动运行 复位热断器 需要清零栓锁超时
//    {
//        alarm_latch.break_reset_flag = false;
//        alarm_latch.break_timeout = 0;
//    }
//}

/**
 * @brief     : 对过载和报警状态进行判断 每2秒判断一次
 * @param[in] : void
 * @return    : none
 * @author    : liukaihua
 * @date      : 20220623
 */
//void equ_read_shorov(void)
//{
////    static uint8_t ehp_shorov_sta_flag = false, ft_shorov_sta_flag = false, blood1_shorov_sta_flag = false, blood2_shorov_sta_flag = false;
////		static uint16_t shorov_sta_cnt = 0;

//    /*************************************电热垫短路或过载判断******************************************/
////	if((DeviceConfig.SYS_CONTRL==DEVICE_BEGIN) && (DeviceConfig.Device_EHP_RUN_CONTRL==DEVICE_BEGIN) && (DeviceConfig.ehp_run_sta == DEVICE_BEGIN))
////    if(Shorov_sta != SHOROV_RESET_START)//只要是非短路或过载复位过程中 都要读报警状态
//    if((Shorov_sta != SHOROV_RESET_START)&&((alarm_latch.shorov_timeout == 0)||(my_shorov_sta.ehp == false)))// 非复位过程中且不栓锁过程中 读报警状态
//    {
//        if(!SHorOVsta_get(EHP_channel))//读取低电平正常
//        {
//            my_shorov_sta.ehp = false; //正常工作状态
//            if((DeviceConfig.ehp_run_sta == DEVICE_STOP)&&(my_break_sta.ehp == false)&&(Dev_stop_flag == false))//若之前是此设备发生了报警且关闭 并且无热断器报警 则需要打开运行
//            {
//                DeviceConfig.ehp_run_sta = DEVICE_BEGIN;
//                LCD_ehp_con();
//            }
//        }
//        else//高电平报警
//        {
//            my_shorov_sta.ehp = true; //短路或过载发生
////            ehp_shorov_sta_flag = true;
//        }
//    }
//    //做报警栓塞 一旦报警 就保持报警 停止设备运行 待设备重新运行再去判断报警状态
////    if((my_shorov_sta.ehp == true)&&(ehp_shorov_sta_flag == true))
//    if((my_shorov_sta.ehp == true)&&(DeviceConfig.ehp_run_sta == DEVICE_BEGIN))//20220924
//    {
////		DeviceConfig.Device_EHP_RUN_CONTRL = DEVICE_STOP ;
//        DeviceConfig.ehp_run_sta = DEVICE_STOP;//故障停止运行状态
//        LCD_ehp_con();
////        ehp_shorov_sta_flag = false;
//    }

//    /*************************************足温短路或过载判断******************************************/
////	if((DeviceConfig.SYS_CONTRL == DEVICE_BEGIN) && (DeviceConfig.Device_FT_RUN_CONTRL == DEVICE_BEGIN) && (DeviceConfig.ft_run_sta == DEVICE_BEGIN))
////    if(Shorov_sta != SHOROV_RESET_START)//只要是非短路或过载复位过程中 都要读报警状态
//    if((Shorov_sta != SHOROV_RESET_START)&&((alarm_latch.shorov_timeout == 0)||(my_shorov_sta.ft == false)))// 非复位过程中且不栓锁过程中 读报警状态
//    {
//        if((!SHorOVsta_get(FT1_channel)) && (!SHorOVsta_get(FT2_channel)))//读取低电平正常
//        {
//            my_shorov_sta.ft = false; //正常工作状态
//            if((DeviceConfig.ft_run_sta == DEVICE_STOP)&&(my_break_sta.ft == false)&&(Dev_stop_flag == false))//若之前是此设备发生了报警且关闭 并且无热断器报警 则需要打开运行
//            {
//                DeviceConfig.ft_run_sta = DEVICE_BEGIN;
//                LCD_ft_con();
//            }
//        }
//        else//高电平报警
//        {
//            my_shorov_sta.ft = true; //短路或过载发生
////            ft_shorov_sta_flag = true;
//        }
//    }
//    //做报警栓塞 一旦报警 就保持报警 停止设备运行 待设备重新运行再去判断报警状态
////    if((my_shorov_sta.ft == true)&&(ft_shorov_sta_flag == true))
//    if((my_shorov_sta.ft == true)&&(DeviceConfig.ft_run_sta == DEVICE_BEGIN))//20220924
//    {
////		DeviceConfig.Device_FT_RUN_CONTRL = DEVICE_STOP ;
//        DeviceConfig.ft_run_sta = DEVICE_STOP;//故障停止运行状态
//        LCD_ft_con();
////        ft_shorov_sta_flag = false;
//    }

//    /*************************************输液1短路或过载判断******************************************/
////	if((DeviceConfig.SYS_CONTRL == DEVICE_BEGIN) && (DeviceConfig.Device_BLOODCH1_RUN_CONTRL == DEVICE_BEGIN) && (DeviceConfig.blood1_run_sta == DEVICE_BEGIN))
////    if(Shorov_sta != SHOROV_RESET_START)//只要是非短路或过载复位过程中 都要读报警状态
//    if((Shorov_sta != SHOROV_RESET_START)&&((alarm_latch.shorov_timeout == 0)||(my_shorov_sta.blood1 == false)))// 非复位过程中且不栓锁过程中 读报警状态
//    {
//        if(!SHorOVsta_get(BLOOD1_channel))//读取低电平正常
//        {
//            my_shorov_sta.blood1 = false; //正常工作状态
//            if((DeviceConfig.blood1_run_sta == DEVICE_STOP)&&(my_break_sta.blood1 == false)&&(Dev_stop_flag == false))//若之前是此设备发生了报警且关闭 并且无热断器报警 则需要打开运行
//            {
//                DeviceConfig.blood1_run_sta = DEVICE_BEGIN;
//                LCD_blood1_con();
//            }
//        }
//        else//高电平报警
//        {
//            my_shorov_sta.blood1 = true; //短路或过载发生
////            blood1_shorov_sta_flag = true;
//        }
//    }
//    //做报警栓塞 一旦报警 就保持报警 停止设备运行 待设备重新运行再去判断报警状态
////    if((my_shorov_sta.blood1 == true)&&(blood1_shorov_sta_flag == true))
//    if((my_shorov_sta.blood1 == true)&&(DeviceConfig.blood1_run_sta == DEVICE_BEGIN))//20220924
//    {
////		DeviceConfig.Device_BLOODCH1_RUN_CONTRL = DEVICE_STOP ;
//        DeviceConfig.blood1_run_sta = DEVICE_STOP;//故障停止运行状态
//        LCD_blood1_con();
////        blood1_shorov_sta_flag = false;
//    }

//    /*************************************输液2短路或过载判断******************************************/
////	if((DeviceConfig.SYS_CONTRL == DEVICE_BEGIN) && (DeviceConfig.Device_BLOODCH2_RUN_CONTRL == DEVICE_BEGIN) && (DeviceConfig.blood2_run_sta == DEVICE_BEGIN))
//    if((Shorov_sta != SHOROV_RESET_START)&&((alarm_latch.shorov_timeout == 0)||(my_shorov_sta.blood2 == false)))// 非复位过程中且不栓锁过程中 读报警状态
////		if(Shorov_sta != SHOROV_RESET_START)//只要是非短路或过载复位过程中  即使栓锁 都要读报警状态
//    {
//        if(!SHorOVsta_get(BLOOD2_channel))//读取低电平正常
//        {
//            my_shorov_sta.blood2 = false; //正常工作状态
//            if((DeviceConfig.blood2_run_sta == DEVICE_STOP)&&(my_break_sta.blood2 == false)&&(Dev_stop_flag == false))//若之前是此设备发生了报警且关闭 并且无热断器报警 则需要打开运行
//            {
//                DeviceConfig.blood2_run_sta = DEVICE_BEGIN;
//                LCD_blood2_con();
//            }
//        }
//        else//高电平报警
//        {
//            my_shorov_sta.blood2 = true; //短路或过载发生
////            blood2_shorov_sta_flag = true;
//        }
//    }
//    //做报警栓塞 一旦报警 就保持报警 停止设备运行 待设备重新运行再去判断报警状态
////    if((my_shorov_sta.blood2 == true)&&(blood2_shorov_sta_flag == true))
//    if((my_shorov_sta.blood2 == true)&&(DeviceConfig.blood2_run_sta == DEVICE_BEGIN))//20220924
//    {
////		DeviceConfig.Device_BLOODCH2_RUN_CONTRL = DEVICE_STOP ;
//        DeviceConfig.blood2_run_sta = DEVICE_STOP;//故障停止运行状态
//        LCD_blood2_con();
////        blood2_shorov_sta_flag = false;
//    }

//    /*********************************************对短路或过载进行复位操作20220819新需求 不能一直栓锁******************************************/
//    switch(Shorov_sta)
//    {
//    case SHOROV_NORMAL://热断器正常状态
//        if((my_shorov_sta.ehp == true)||(my_shorov_sta.ft == true)||(my_shorov_sta.blood1 == true)||(my_shorov_sta.blood2 == true))//若有报警栓锁 触发复位 解除栓锁
//        {
//            alarm_latch.shorov_timeout++;
//            if(alarm_latch.shorov_timeout >= SHOV_TIMEOUT)//热断器报警发生 栓锁10分钟后再复位  20220924
//            {
//                gpio_bit_reset(RESET_SHOROVBJ_GPIO_PORT, RESET_SHOROVBJ_PIN);//开机短路或过载报警复位 di电平复位
//                Shorov_sta = SHOROV_RESET_START;
//                alarm_latch.shorov_timeout = 0;
//            }
//        }
//        else
//        {
//            alarm_latch.shorov_timeout = 0;
//        }
//        break;
//    case SHOROV_RESET_START://热断器复位开始状态
//        gpio_bit_set(RESET_SHOROVBJ_GPIO_PORT, RESET_SHOROVBJ_PIN);
//        Shorov_sta = SHOROV_RESET_END;
//        break;
//    case SHOROV_RESET_END://热断器复位结束状态
//        Shorov_sta = SHOROV_NORMAL;
//        break;
//    default:
//        break;
//    }
//    if(alarm_latch.shorov_reset_flag == true)//系统重启动运行 复位短路过载报警 需要清零栓锁超时
//    {
//        alarm_latch.shorov_reset_flag = false;
//        alarm_latch.shorov_timeout = 0;
//    }
//}

/**
 * @brief     : 对设备脱落状态进行判断 每2秒判断一次 进行报警
 * @param[in] : void
 * @return    : none
 * @author    : liukaihua
 * @date      : 20220623
 */
void equ_read_off(void)
{
    /*************************************上身毯设备脱落判断******************************************/
    if(DeviceConfig.Bp_Temp_EnableSta.UpperBlanket == true)//设备使能后判断脱落
    {
        if(DeviceConfig.Bp_Temp_Islive.UpperBlanket == false)//不存活 报脱落
            my_equoff_sta.UpperBlanket = true;
        else
            my_equoff_sta.UpperBlanket = false;
    }
    else
        my_equoff_sta.UpperBlanket = false;
    
    if(DeviceConfig.Bp_Temp_EnableSta.LowBlanket == true)//设备使能后判断脱落
    {
        if(DeviceConfig.Bp_Temp_Islive.LowBlanket == false)//不存活 报脱落
            my_equoff_sta.LowBlanket = true;
        else
            my_equoff_sta.LowBlanket = false;
    }
    else
        my_equoff_sta.LowBlanket = false;
    
    if(DeviceConfig.Bp_Temp_EnableSta.ArmBlanket1 == true)//设备使能后判断脱落
    {
        if(DeviceConfig.Bp_Temp_Islive.ArmBlanket1 == false)//不存活 报脱落
            my_equoff_sta.ArmBlanket1 = true;
        else
            my_equoff_sta.ArmBlanket1 = false;
    }
    else
        my_equoff_sta.ArmBlanket1 = false;
    
    if(DeviceConfig.Bp_Temp_EnableSta.ArmBlanket2 == true)//设备使能后判断脱落
    {
        if(DeviceConfig.Bp_Temp_Islive.ArmBlanket2 == false)//不存活 报脱落
            my_equoff_sta.ArmBlanket2 = true;
        else
            my_equoff_sta.ArmBlanket2 = false;
    }
    else
        my_equoff_sta.ArmBlanket2 = false;
    
    if(DeviceConfig.Bp_Temp_EnableSta.BLOODCH1 == true)//设备使能后判断脱落
    {
        if((DeviceConfig.Bp_Temp_Islive.blood1 == false)||(my_equoff_itself_sta.blood1 == true))//不存活 或设备自身脱落 报脱落
            my_equoff_sta.blood1 = true;
        else
            my_equoff_sta.blood1 = false;
    }
    else
        my_equoff_sta.blood1 = false;
    
    if(DeviceConfig.Bp_Temp_EnableSta.BLOODCH2 == true)//设备使能后判断脱落
    {
        if((DeviceConfig.Bp_Temp_Islive.blood2 == false)||(my_equoff_itself_sta.blood2 == true))//不存活 或设备自身脱落 报脱落
            my_equoff_sta.blood2 = true;
        else
            my_equoff_sta.blood2 = false;
    }
    else
        my_equoff_sta.blood2 = false;
    
    if(DeviceConfig.Bp_Temp_EnableSta.FT1 == true)//设备使能后判断脱落
    {
        if(DeviceConfig.Bp_Temp_Islive.FT1 == false)//不存活 报脱落
            my_equoff_sta.FT1 = true;
        else
            my_equoff_sta.FT1 = false;
    }
    else
        my_equoff_sta.FT1 = false;
    
    if(DeviceConfig.Bp_Temp_EnableSta.FT2 == true)//设备使能后判断脱落
    {
        if(DeviceConfig.Bp_Temp_Islive.FT2 == false)//不存活 报脱落
            my_equoff_sta.FT2 = true;
        else
            my_equoff_sta.FT2 = false;
    }
    else
        my_equoff_sta.FT2 = false;
    
    if(DeviceConfig.Bp_Temp_EnableSta.InfusePress1 == true)//设备使能后判断脱落
    {
        if(DeviceConfig.Bp_Temp_Islive.InfusePress1 == false)//不存活 报脱落
            my_equoff_sta.InfusePress1 = true;
        else
            my_equoff_sta.InfusePress1 = false;
    }
    else
        my_equoff_sta.InfusePress1 = false;
    
    if(DeviceConfig.Bp_Temp_EnableSta.InfusePress2 == true)//设备使能后判断脱落
    {
        if(DeviceConfig.Bp_Temp_Islive.InfusePress2 == false)//不存活 报脱落
            my_equoff_sta.InfusePress2 = true;
        else
            my_equoff_sta.InfusePress2 = false;
    }
    else
        my_equoff_sta.InfusePress2 = false;
    
//    /*************************************电热垫设备脱落判断  设备运行再报警脱落******************************************/
//    if((DeviceConfig.SYS_CONTRL == DEVICE_BEGIN)&&(DeviceConfig.Device_EHP_RUN_CONTRL == DEVICE_BEGIN) &&(DeviceConfig.ehp_run_sta == DEVICE_BEGIN))
////    if((DeviceConfig.SYS_CONTRL == DEVICE_BEGIN)&&(DeviceConfig.Device_EHP_RUN_CONTRL == DEVICE_BEGIN))//20220924 加热设备使能 且系统运行就判断脱落
//    {
//        if((EquOffsta_get(EHP_channel))&&(my_equoff_sta.ex_ehp == false))
//            my_equoff_sta.ehp = true; //脱落
//        else
//            my_equoff_sta.ehp = false; //未脱落

//        if(!EquOffsta_get(EHP_channel))
//            my_equoff_sta.ex_ehp = false; //运行状态时 出现未脱落
//    }
//    else
//    {
//        my_equoff_sta.ehp = false; //不运行不报警脱落

//        if(EquOffsta_get(EHP_channel))
//            my_equoff_sta.ex_ehp = true; //待机状态时 脱落
//        else
//            my_equoff_sta.ex_ehp = false; //待机状态时 未脱落
//    }

//    /*************************************足温设备脱落判断  设备运行再报警脱落******************************************/
//    //20221105关闭测试
//    if((DeviceConfig.SYS_CONTRL == DEVICE_BEGIN)&&(DeviceConfig.Device_FT_RUN_CONTRL == DEVICE_BEGIN) &&(DeviceConfig.ft_run_sta == DEVICE_BEGIN))
////		if((DeviceConfig.SYS_CONTRL == DEVICE_BEGIN)&&(DeviceConfig.Device_FT_RUN_CONTRL == DEVICE_BEGIN))//20220924 加热设备使能 且系统运行就判断脱落
//    {
//        if((EquOffsta_get(FT1_channel))&&(my_equoff_sta.ex_ft == false))
//            my_equoff_sta.ft = true; //脱落
//        else
//            my_equoff_sta.ft = false; //未脱落

//        if(!EquOffsta_get(FT1_channel))
//            my_equoff_sta.ex_ft = false; //运行状态时 出现未脱落
//    }
//    else
//    {
//        my_equoff_sta.ft = false; //不运行不报警脱落

//        if(EquOffsta_get(FT1_channel))
//            my_equoff_sta.ex_ft = true; //待机状态时 脱落
//        else
//            my_equoff_sta.ex_ft = false; //待机状态时 未脱落
//    }

//    /*************************************输液1设备脱落判断  设备运行再报警脱落******************************************/
//    if((DeviceConfig.SYS_CONTRL == DEVICE_BEGIN)&&(DeviceConfig.Device_BLOODCH1_RUN_CONTRL == DEVICE_BEGIN) &&(DeviceConfig.blood1_run_sta == DEVICE_BEGIN))
////		if((DeviceConfig.SYS_CONTRL == DEVICE_BEGIN)&&(DeviceConfig.Device_BLOODCH1_RUN_CONTRL == DEVICE_BEGIN))//20220924 加热设备使能 且系统运行就判断脱落
//    {
//        if((EquOffsta_get(BLOOD1_channel))&&(my_equoff_sta.ex_blood1 == false))
//            my_equoff_sta.blood1 = true; //脱落
//        else
//            my_equoff_sta.blood1 = false; //未脱落

//        if(!EquOffsta_get(BLOOD1_channel))
//            my_equoff_sta.ex_blood1 = false; //运行状态时 出现未脱落
//    }
//    else
//    {
//        my_equoff_sta.blood1 = false; //不运行不报警脱落

//        if(EquOffsta_get(BLOOD1_channel))
//            my_equoff_sta.ex_blood1 = true; //待机状态时 脱落
//        else
//            my_equoff_sta.ex_blood1 = false; //待机状态时 未脱落
//    }

//    /*************************************输液2设备脱落判断  设备运行再报警脱落******************************************/
//    if((DeviceConfig.SYS_CONTRL == DEVICE_BEGIN)&&(DeviceConfig.Device_BLOODCH2_RUN_CONTRL == DEVICE_BEGIN) &&(DeviceConfig.blood2_run_sta == DEVICE_BEGIN))
////		if((DeviceConfig.SYS_CONTRL == DEVICE_BEGIN)&&(DeviceConfig.Device_BLOODCH2_RUN_CONTRL == DEVICE_BEGIN))//20220924 加热设备使能 且系统运行就判断脱落
//    {
//        if((EquOffsta_get(BLOOD2_channel))&&(my_equoff_sta.ex_blood2 == false))
//            my_equoff_sta.blood2 = true; //脱落
//        else
//            my_equoff_sta.blood2 = false; //未脱落

//        if(!EquOffsta_get(BLOOD2_channel))
//            my_equoff_sta.ex_blood2 = false; //运行状态时 出现未脱落
//    }
//    else
//    {
//        my_equoff_sta.blood2 = false; //不运行不报警脱落

//        if(EquOffsta_get(BLOOD2_channel))
//            my_equoff_sta.ex_blood2 = true; //待机状态时 脱落
//        else
//            my_equoff_sta.ex_blood2 = false; //待机状态时 未脱落
//    }
}

/**
 * @brief     : 申请数据命令打包发送
 * @param[in] : void
 * @return    : none
 * @author    : liukaihua
 * @date      : 2024.3.31
 */
void ReqData_cmd_pack(void)
{
    uint8_t data=0;
    if(DeviceConfig.Bp_Temp_Islive.InfusePress1)//存活则申请数据
    {
        InterComm_485_PackData(INTER485_HEAT_REQdata_CMD, INTER_485COMM_ADDR_InfusePress1, &data, sizeof(data));
    }
    if(DeviceConfig.Bp_Temp_Islive.InfusePress2)//存活则申请数据
    {
        InterComm_485_PackData(INTER485_HEAT_REQdata_CMD, INTER_485COMM_ADDR_InfusePress2, &data, sizeof(data));
    }
    if(DeviceConfig.Bp_Temp_Islive.blood1)//存活则申请数据
    {
        InterComm_485_PackData(INTER485_HEAT_REQdata_CMD, INTER_485COMM_ADDR_Blood1, &data, sizeof(data));
    }
    if(DeviceConfig.Bp_Temp_Islive.blood2)//存活则申请数据
    {
        InterComm_485_PackData(INTER485_HEAT_REQdata_CMD, INTER_485COMM_ADDR_Blood2, &data, sizeof(data));
    }
    if(DeviceConfig.Bp_Temp_Islive.ArmBlanket1)//存活则申请数据
    {
        InterComm_485_PackData(INTER485_HEAT_REQdata_CMD, INTER_485COMM_ADDR_ArmBlanket1, &data, sizeof(data));
    }
    if(DeviceConfig.Bp_Temp_Islive.ArmBlanket2)//存活则申请数据
    {
        InterComm_485_PackData(INTER485_HEAT_REQdata_CMD, INTER_485COMM_ADDR_ArmBlanket2, &data, sizeof(data));
    }
    if(DeviceConfig.Bp_Temp_Islive.UpperBlanket)//存活则申请数据
    {
        InterComm_485_PackData(INTER485_HEAT_REQdata_CMD, INTER_485COMM_ADDR_UpperBlanket, &data, sizeof(data));
    }
    if(DeviceConfig.Bp_Temp_Islive.LowBlanket)//存活则申请数据
    {
        InterComm_485_PackData(INTER485_HEAT_REQdata_CMD, INTER_485COMM_ADDR_LowBlanket, &data, sizeof(data));
    }
    if(DeviceConfig.Bp_Temp_Islive.FT1)//存活则申请数据
    {
        InterComm_485_PackData(INTER485_HEAT_REQdata_CMD, INTER_485COMM_ADDR_FT1, &data, sizeof(data));
    }
    if(DeviceConfig.Bp_Temp_Islive.FT2)//存活则申请数据
    {
        InterComm_485_PackData(INTER485_HEAT_REQdata_CMD, INTER_485COMM_ADDR_FT2, &data, sizeof(data));
    }
}
/**
 * @brief     : 主任务 获取当前温度 并进行自动控制 2s定时申请数据
 * @param[in] : void
 * @return    : none
 * @author    : liukaihua
 * @date      : 20220121
 */
void ValveControlTimingHandle(void)
{
    UpDateDeviceStatus();//获取温度值 并将数据发送到LCD

//    equ_read_break();//每2秒读一次断路器故障状态
//    equ_read_shorov();//读取过载或短路故障状态
    equ_read_off();//读取设备脱落故障状态

    //test20220718
//		NetFibocom_SendCMD(AT_GTUSIM_CHECK, strlen(AT_GTUSIM_CHECK));
    //test20220718
    dev_info_pack();//20220824 打包加热设备的温度信息发送给网络端 2秒发送一次

//    AutoMode_temp_set();//20220906 每2秒判断一次自动模式下的目标温度差 判断要做滤波
    ReqData_cmd_pack();//每2秒请求一次数据
}

/**
 * @brief     : 采集数据均值滤波
 * @param[in] : uint16_t *indata 要进行滤波的数据   uint8_t cal_cnt数据累计个数  uint8_t num_total 滤波数据总个数
 * @return    : 返回滤波结果
 * @author    : liukaihua
 * @date      : 20221024
 */
float mean_filter(float *indata, uint8_t cal_cnt, uint8_t num_total)
{
    float sumdata=0, avgdata=0;
    uint8_t actual_cnt = num_total;
    if(cal_cnt >= num_total)//数据累计够数
    {
        for(uint8_t i=0; i<num_total; i++)
        {
            sumdata += indata[i];
        }
        avgdata = sumdata / num_total;
        sumdata = 0;
        for(uint8_t i=0; i<num_total; i++)
        {
            if((indata[i] >= (avgdata + 1))||(indata[i] <= (avgdata - 1)))//若有超过1度的数据 直接剔除掉
            {
                actual_cnt--;
                if(actual_cnt > 0)//若都减掉 则保留最后一个值 20221221
                    indata[i] = 0;
                else
                    actual_cnt =1;//保证除数不能为0 20221221
            }
            sumdata += indata[i];
        }
        avgdata = sumdata / actual_cnt;
    }
    else
        avgdata = indata[cal_cnt-1];//数据量不够平均 输出当前值

    return avgdata;
}

/**
 * @brief     : 各个设备的pid调用
 * @param[in] : void
 * @return    : none
 * @author    : liukaihua
 * @date      : 20220407
 */
/*=====================================================================================*/
//void pid_cal_blood1(uint16_t temp_set)
//{
//    uint16_t adc;
//    float temp, pidout, temp_calib ;
//    static uint8_t cal_cnt=0 ;
//    static float cal_data[NUM_FILTER];//累计采集次数
////	STM_EVAL_LEDOff(LED1);//test

//    pid_parm_blood1.Set_Point = (float)temp_set / 10.0 ;//20220905 DeviceDATA.blood_ch1_temp_set /10.0 ; //算出真正设置的温度值

//    adc = ADC_Average_VALUE(ADC_BLOOD1_CHANNEL);
//    if(adc < 4000)
//    {
//        temp = (float)Get_Tempture_10k(adc) /10.0 ;//获取输血输液CH1温度
//        //温度补偿
//        temp_calib = Device_calib.blood1 / 10.0;//
//        temp = temp + temp_calib;

//        cal_data[cal_cnt++] = temp;
//        temp =  mean_filter(&cal_data[0], cal_cnt, NUM_FILTER);//做NUM_FILTER个点均值滤波
//        if(cal_cnt >= NUM_FILTER)
//        {
//            cal_cnt=0;

//            pidout = Pid_Calculate_real(temp, &pid_parm_blood1, 0); //获得pwm占空比里面的有效数值

//            //设置pwm新的占空比
//            if((pidout >= 1)&&(pidout < BLOOD_PWMDUTY_UPPER))
//                pidout = pidout - 1;
//            BLOOD1_pwm_setduty((uint16_t)pidout);
//        }
//    }
//    else //传感器未接入 不调用pid
//    {
//        temp = 0;
//        BLOOD1_pwm_stop();//关停加热

//        cal_cnt =0;
//    }
////	STM_EVAL_LEDOn(LED1);//test
//}

//void pid_cal_blood2(uint16_t temp_set)
//{
//    uint16_t adc;
//    float temp, pidout, temp_calib ;
//    static uint8_t cal_cnt=0 ;
//    static float cal_data[NUM_FILTER];//累计采集次数

//    pid_parm_blood2.Set_Point = (float)temp_set / 10.0 ;//20220905 DeviceDATA.blood_ch2_temp_set /10.0 ; //算出真正设置的温度值

//    adc = ADC_Average_VALUE(ADC_BLOOD2_CHANNEL);
//    if(adc < 4000)
//    {
//        temp = (float)Get_Tempture_10k(adc) /10.0 ;//获取输血输液CH1温度
//        //温度补偿
//        temp_calib = Device_calib.blood2 / 10.0;
//        temp = temp + temp_calib;

//        cal_data[cal_cnt++] = temp;
//        temp =  mean_filter(&cal_data[0], cal_cnt, NUM_FILTER);//做NUM_FILTER个点均值滤波
//        if(cal_cnt >= NUM_FILTER)
//        {
//            cal_cnt=0;
//            pidout = Pid_Calculate_real(temp, &pid_parm_blood2, 1); //获得pwm占空比里面的有效数值

//            //设置pwm新的占空比
//            if((pidout >= 1)&&(pidout < BLOOD_PWMDUTY_UPPER))
//                pidout = pidout - 1;
//            BLOOD2_pwm_setduty((uint16_t)pidout);
//        }
//    }
//    else //传感器未接入 不调用pid
//    {
//        temp = 0;
//        BLOOD2_pwm_stop();//关停加热

//        cal_cnt =0;
//    }
//}

//void pid_cal_ehp(uint16_t temp_set)
//{
//    uint16_t adc, adc2;
//    float temp, pidout, temp_calib, temp2;
//    static uint8_t cal_cnt=0 ;
//    static float cal_data[NUM_FILTER];//累计采集次数

//    pid_parm_ehp.Set_Point = (float)temp_set / 10.0 ;//20220905 DeviceDATA.ehp_temp_set /10.0 ; //算出真正设置的温度值

//    adc = ADC_Average_VALUE(ADC_EHP_CHANNEL);
//    adc2 = ADC_Average_VALUE(ADC_EHP2_CHANNEL);//第2个热敏电阻通道

//    //if(adc < 4000)
//    if((adc < 4000)||(adc2 < 4000))//有任何一路接入都可以      //if(adc2 < 4000)//
//    {
//        if(adc < 4000)
//            temp = (float)Get_Tempture_50k_ehp(adc) /10.0 ;//获取温度
//        if(adc2 < 4000)
//            temp2 = (float)Get_Tempture_50k_ehp(adc2) /10.0 ;//获取温度
//        if((temp2 > temp)&&(temp2 < 100))//此限制后面看如果限定？
//            temp = temp2;
////        temp = (float)Get_Tempture_50k_ehp(adc2) /10.0 ;//获取温度

////		if(temp >= EHP_TEMP_PID_OFFSET)//电热垫有温度补偿
////				temp = temp - EHP_TEMP_PID_OFFSET;
//        //温度补偿
//        temp_calib = Device_calib.ehp / 10.0;
//        temp = temp + temp_calib;

//        cal_data[cal_cnt++] = temp;
//        temp =  mean_filter(&cal_data[0], cal_cnt, NUM_FILTER);//做NUM_FILTER个点均值滤波
//        if(cal_cnt >= NUM_FILTER)
//        {
//            cal_cnt=0;
//            pidout = Pid_Calculate(temp, &pid_parm_ehp, 2); //获得pwm占空比里面的有效数值

//            //设置pwm新的占空比
//            if((pidout >= 1)&&(pidout < EHP_PWMDUTY_UPPER))
//                pidout = pidout - 1;
//            EHP_pwm_setduty((uint16_t)pidout);
//        }
//    }
//    else //传感器未接入 不调用pid
//    {
//        temp = 0;
//        EHP_pwm_stop();//关停加热

//        cal_cnt=0;
//    }
//}

//void pid_cal_ft(uint16_t temp_set)
//{
//    uint16_t adc;
//    float temp, pidout, temp_calib ;
//    static uint8_t cal_cnt=0 ;
//    static float cal_data[NUM_FILTER];//累计采集次数

//    pid_parm_ft.Set_Point = (float)temp_set / 10.0 ;//20220905 DeviceDATA.ft_temp_set /10.0 ; //算出真正设置的温度值

//    adc = ADC_Average_VALUE(ADC_FT_CHANNEL);
//    if(adc < 4000)
//    {
//        temp = (float)Get_Tempture_50k_ft(adc) /10.0 ;//获取温度
//        //温度补偿
//        temp_calib = Device_calib.ft / 10.0;
//        temp = temp + temp_calib;

//        cal_data[cal_cnt++] = temp;
//        temp =  mean_filter(&cal_data[0], cal_cnt, NUM_FILTER);//做NUM_FILTER个点均值滤波
//        if(cal_cnt >= NUM_FILTER)
//        {
//            cal_cnt=0;
////            pidout = Pid_Calculate_real(temp, &pid_parm_ft, 3); //获得pwm占空比里面的有效数值
//            pidout = Pid_Calculate(temp, &pid_parm_ft, 3);

//            //设置pwm新的占空比
//            if((pidout >= 1)&&(pidout < FT_PWMDUTY_UPPER))
//                pidout = pidout - 1;
//            FT_pwm_setduty((uint16_t)pidout);
//        }
//    }
//    else //传感器未接入 不调用pid
//    {
//        temp = 0;
//        FT_pwm_stop();//关停加热

//        cal_cnt=0;
//    }
//}
//void pid_cal_ft2(uint16_t temp_set)
//{
//    uint16_t adc;
//    float temp, pidout, temp_calib ;
//    static uint8_t cal_cnt=0 ;
//    static float cal_data[NUM_FILTER];//累计采集次数

//    pid_parm_ft2.Set_Point = (float)temp_set / 10.0 ;//20220905 DeviceDATA.ft_temp_set /10.0 ; //算出真正设置的温度值

//    adc = ADC_Average_VALUE(ADC_FT2_CHANNEL);
//    if(adc < 4000)
//    {
//        temp = (float)Get_Tempture_50k_ft(adc) /10.0 ;//获取温度
//        //温度补偿
//        temp_calib = Device_calib.ft / 10.0;
//        temp = temp + temp_calib;
//        cal_data[cal_cnt++] = temp;
//        temp =  mean_filter(&cal_data[0], cal_cnt, NUM_FILTER);//做NUM_FILTER个点均值滤波
//        if(cal_cnt >= NUM_FILTER)
//        {
//            cal_cnt=0;
////            pidout = Pid_Calculate_real(temp, &pid_parm_ft2, 4); //获得pwm占空比里面的有效数值
//            pidout = Pid_Calculate(temp, &pid_parm_ft2, 4);

//            //设置pwm新的占空比
//            if((pidout >= 1)&&(pidout < FT_PWMDUTY_UPPER))
//                pidout = pidout - 1;
//            FT2_pwm_setduty((uint16_t)pidout);
//        }
//    }
//    else //传感器未接入 不调用pid
//    {
//        temp = 0;
//        FT2_pwm_stop();//关停加热
//        cal_cnt=0;
//    }
//}
/*=====================================================================================*/

/**
 * @brief     : 对各设备自动控制调用
 * @param[in] : void
 * @return    : none
 * @author    : liukaihua
 * @date      : 20220414
 */
//void pid_calculate_equ(void)
//{
//    static uint8_t timecnt_reset =0;
//    static uint16_t blood1_tempset_ex = 0, blood2_tempset_ex = 0, ft_tempSet_ex = 0, ehp_tempset_ex = 0;
////		uint16_t blood1_tempSet, blood2_tempSet, ehp_tempSet, ft_tempSet ;

//    UpDateDeviceStatus();//获取温度值 并且有脱落报警的判断

//    if(DeviceConfig.SYS_CONTRL == DEVICE_BEGIN)//系统开始运行后进行温度调控
//    {
////        switch(DeviceConfig.work_mode)//判断工作模式后再加热工作 20220905
////				{
////					case AUTO_MODE:
//////						blood1_tempSet = judge_temp_set();//判断加热设备的加热温度值
//////						blood2_tempSet = blood1_tempSet ;
//////						ehp_tempSet = blood1_tempSet ;
//////						ft_tempSet = blood1_tempSet ;
////						break;
////					case MANUAL_MODE://手动模式不用一直赋值
////					default:
////						//DeviceConfig中的温度设置 用于实际使用 如加热、报警使用参考
////            //若手动模式等同于DeviceData里面的设置，即用于显示的设置温度
////					  //若自动模式需要单独赋值 不等于DeviceData里面的设置
//////						memcpy(&DeviceConfig.ehp_tempSet, &DeviceDATA.ehp_temp_set, 8);
////						break;
////				}

//        if((DeviceConfig.Device_BLOODCH1_RUN_CONTRL == DEVICE_BEGIN) &&(DeviceConfig.blood1_run_sta == DEVICE_BEGIN))//输液器1加热的运行控制 开始
//        {
//            if(blood1_tempset_ex != DeviceConfig.blood1_tempSet)//若更改了设置温度，需要重新初始化pid
//                InitPid_blood1();//初始化pid参数 pid开始工作
//            else
//                pid_cal_blood1(DeviceConfig.blood1_tempSet); //输液管1 pid调用

//            blood1_tempset_ex = DeviceConfig.blood1_tempSet;
//        }

//        if((DeviceConfig.Device_BLOODCH2_RUN_CONTRL == DEVICE_BEGIN) && (DeviceConfig.blood2_run_sta == DEVICE_BEGIN))//输液器2加热的运行控制 开始
//        {
//            if(blood2_tempset_ex != DeviceConfig.blood2_tempSet)//若更改了设置温度，需要重新初始化pid
//                InitPid_blood2();//初始化pid参数 pid开始工作
//            else
//                pid_cal_blood2(DeviceConfig.blood2_tempSet);

//            blood2_tempset_ex = DeviceConfig.blood2_tempSet;
//        }

//        if((DeviceConfig.Device_EHP_RUN_CONTRL == DEVICE_BEGIN) && (DeviceConfig.ehp_run_sta == DEVICE_BEGIN))//电热垫加热的运行控制 开始
//        {
//            if(ehp_tempset_ex != DeviceConfig.ehp_tempSet)//若更改了设置温度，需要重新初始化pid
//                InitPid_ehp();//初始化pid参数 pid开始工作
//            else
//                pid_cal_ehp(DeviceConfig.ehp_tempSet);

//            ehp_tempset_ex = DeviceConfig.ehp_tempSet;

//        }

//        if((DeviceConfig.Device_FT_RUN_CONTRL == DEVICE_BEGIN) && (DeviceConfig.ft_run_sta == DEVICE_BEGIN))//足温垫加热的运行控制 开始
//        {
//            if(ft_tempSet_ex != DeviceConfig.ft_tempSet)//若更改了设置温度，需要重新初始化pid
//            {
//                InitPid_ft();//初始化pid参数 pid开始工作
//                InitPid_ft2();//初始化pid参数 pid开始工作
//            }
//            else
//            {
//                pid_cal_ft(DeviceConfig.ft_tempSet);
//                pid_cal_ft2(DeviceConfig.ft_tempSet);//足温垫第2路
//            }

//            ft_tempSet_ex = DeviceConfig.ft_tempSet;
//        }

//#ifdef PID_DEBUG_MODE
//				static uint8_t dbg_cnt = 0;
//				dbg_cnt ++;
//				if(dbg_cnt >= NUM_FILTER)
//				{
//					dbg_cnt = 0;
//					pid_debugdata_pack();//pid调试数据输出
//				}
//#endif

//        //系统运行后，首先判断是否需要完成热断器和短路过载报警的复位操作
//        if((Reset_break_sta)||(Reset_shorov_sta))
//        {
//            timecnt_reset ++;
//            if(timecnt_reset >= 10)//10*100ms=1s 20221016  25)//改成1秒 3 )//累计3次 即40ms*3 = 120ms的复位时长即可
//            {
//                if(Reset_break_sta)
//                {
//                    gpio_bit_reset(RESET_RDQBJ_GPIO_PORT, RESET_RDQBJ_PIN);
//                    Reset_break_sta = false;
//                    alarm_latch.break_reset_flag = true;//系统重启动运行 复位栓锁报警后 需要去清零栓锁报警超时
//                }
//                if(Reset_shorov_sta)
//                {
//                    gpio_bit_set(RESET_SHOROVBJ_GPIO_PORT, RESET_SHOROVBJ_PIN);
//                    Reset_shorov_sta = false;
//                    alarm_latch.shorov_reset_flag = true;//系统重启动运行 复位栓锁报警后 需要去清零栓锁报警超时
//                }
//                timecnt_reset = 0;
//            }
//        }
//    }
//}

/**
 * @brief     : 自动模式下 判断加热设备需要工作的温度值 自动加热模式下的启停，要参考热断器和短路报警
 * @param[in] : void
 * @return    : none
 * @author    : liukaihua
 * @date      : 20220906
 */
//void AutoMode_temp_set(void)
//{
//    static uint8_t init_sta_pre = false;//滑动平均初始化的标志位
//    uint16_t EarTemp_remove_noise = 0;

//    if(DeviceDATA.ear_isconnect == true)//耳温贴连接着 处理耳温贴数据
//        EarTemp_remove_noise = (uint16_t)wismed_movmean(DeviceDATA.ear_temp_now, 10, Wismed_Movmean_Work_Normal, &movMeanEarTemp);
//    else
//        EarTemp_remove_noise = 0;

//    if(DeviceConfig.work_mode == AUTO_MODE)
//    {
//        if(DeviceDATA.ear_isconnect == true)
//        {
//            if(EarTemp_remove_noise< 280 )//体温低于28度
//            {
//                DeviceConfig.blood1_tempSet = 360;
//                DeviceConfig.blood2_tempSet = 360;
//                DeviceConfig.ehp_tempSet = 360;
//                DeviceConfig.ft_tempSet = 360;
//            }
//            else if((EarTemp_remove_noise + 3 ) < DeviceDATA.targert_eartemp)//温差大于0.3度
//            {
//                DeviceConfig.blood1_tempSet = 400;
//                DeviceConfig.blood2_tempSet = 400;
//                DeviceConfig.ehp_tempSet = 400;
//                DeviceConfig.ft_tempSet = 400;
//            }
//            else if(((EarTemp_remove_noise + 3 ) >= DeviceDATA.targert_eartemp)&&(EarTemp_remove_noise <= DeviceDATA.targert_eartemp))//温差在0.3与0之间
//            {
//                DeviceConfig.blood1_tempSet = 380;
//                DeviceConfig.blood2_tempSet = 380;
//                DeviceConfig.ehp_tempSet = 380;
//                DeviceConfig.ft_tempSet = 380;
//            }
//            else if((EarTemp_remove_noise > DeviceDATA.targert_eartemp)&&(EarTemp_remove_noise <=370))//体温大于目标温度小于等于37度
//            {
//                DeviceConfig.blood1_tempSet = 360;
//                DeviceConfig.blood2_tempSet = 360;
//                DeviceConfig.ehp_tempSet = 360;
//                DeviceConfig.ft_tempSet = 360;
//            }
//        }

//        if ((EarTemp_remove_noise > 370)||(DeviceDATA.ear_isconnect == false))//人体温度超过37度 或者耳温不连接 需要停止加热
//        {
//            if(Dev_stop_flag == false)
//            {
//                DeviceConfig.blood1_run_sta = DEVICE_STOP;
//                DeviceConfig.blood2_run_sta = DEVICE_STOP;
//                DeviceConfig.ehp_run_sta = DEVICE_STOP;
//                DeviceConfig.ft_run_sta = DEVICE_STOP;
//                LCD_blood1_con();
//                LCD_blood2_con();
//                LCD_ehp_con();
//                LCD_ft_con();
//                Dev_stop_flag = true;
//            }
//        }
//        else
//        {
//            Dev_stop_flag = false;
//            if((my_break_sta.blood1 == false)&&(my_shorov_sta.blood1 == false)&&(DeviceConfig.blood1_run_sta == DEVICE_STOP))//无热断器和短路报警 才可以开始加热运行
//            {
//                DeviceConfig.blood1_run_sta = DEVICE_BEGIN;
//                LCD_blood1_con();
//            }
//            if((my_break_sta.blood2 == false)&&(my_shorov_sta.blood2 == false)&&(DeviceConfig.blood2_run_sta == DEVICE_STOP))//无热断器和短路报警 才可以开始加热运行
//            {
//                DeviceConfig.blood2_run_sta = DEVICE_BEGIN;
//                LCD_blood2_con();
//            }
//            if((my_break_sta.ehp == false)&&(my_shorov_sta.ehp == false)&&(DeviceConfig.ehp_run_sta == DEVICE_STOP))//无热断器和短路报警 才可以开始加热运行
//            {
//                DeviceConfig.ehp_run_sta = DEVICE_BEGIN;
//                LCD_ehp_con();
//            }
//            if((my_break_sta.ft == false)&&(my_shorov_sta.ft == false)&&(DeviceConfig.ft_run_sta == DEVICE_STOP))//无热断器和短路报警 才可以开始加热运行
//            {
//                DeviceConfig.ft_run_sta = DEVICE_BEGIN;
//                LCD_ft_con();
//            }
//        }
//    }
//    else//手动模式清零自动模式的停止运行标志位 20220925
//    {
//        Dev_stop_flag = false;

//        if(DeviceConfig.SYS_CONTRL == DEVICE_BEGIN)//系统开始运行后进行温度调控
//        {
//            if((DeviceDATA.ear_isconnect) && (EarTemp_remove_noise >= alarm_phy_parm.ear_h))//耳温连接 且 人体温度大于设定的报警稳定停止运行 此处待定？
//            {
//                DeviceConfig.SYS_CONTRL = DEVICE_STOP;
//                Other_sys_con();//非lcd 其他的系统控制
//            }
//        }
//    }

//    //耳温贴断开初始化温度数据的滑动平均缓存
//    if((DeviceDATA.ear_isconnect == false)&&(init_sta_pre == false))//断开后未初始化过 需要初始化一次
//    {
//        wismed_movean_init(&movMeanEarTemp);//初始化耳温数据的滑动平均值
//        init_sta_pre = true;
//    }
//    else if(DeviceDATA.ear_isconnect == true)//耳温连接上
//        init_sta_pre = false;
//}

/**
 * @brief     : 调试pid参数使用 通过网络输出pid的相关数据
 * @param[in] : void
 * @return    : none
 * @author    : liukaihua
 * @date      : 20221016
 */
void pid_debugdata_pack(void)
{
    int16_t sum_tmp;
    uint8_t tx_buf[INTER_COMM_CMD_MAX_LEN];
    static uint8_t pack_cnt=0;
    uint8_t data_len = sizeof(PID_DEBUG_DATA_t);//所有pid相关输出数据
    PID_DEBUG_DATA_t *pdata = (PID_DEBUG_DATA_t *)&tx_buf[INTER_COMM_HEAD_LEN];
    INTER_COMM_HEAD_t *p_head = (INTER_COMM_HEAD_t *)tx_buf;
    INTER_COMM_TAIL_t *p_tail = (INTER_COMM_TAIL_t *)&tx_buf[INTER_COMM_HEAD_LEN + data_len];

    p_head->prefix = 0xAAAA;
    p_head->src = INTER_COMM_ADDR_STM32;
    p_head->dst = INTER_COMM_ADDR_NET;
    p_head->cmd = INTER_HEAT_DEBUG;//0x8F
    p_head->len = data_len;
    memcpy(p_head->mac_addr, my_bleinfo.hub_mac, 6);

    memcpy(pdata->mac_addr , my_bleinfo.dev_info[DEV_WMTC].mac_addr, 6);

    pdata->blood1_SetTemp = pid_parm_blood1.Set_Point *10 ;
    pdata->blood1_NowTemp = pid_parm_blood1.Now_Point *10 ;
    pdata->blood1_PwmOut = pid_parm_blood1.Out ;
    sum_tmp = pid_parm_blood1.Sum_Error *100;
    if(sum_tmp >= 32767)
        sum_tmp = 32767;
    else if (sum_tmp <= -32768)
        sum_tmp = -32768;
    pdata->blood1_SumErr = sum_tmp ;

    pdata->blood2_SetTemp = pid_parm_blood2.Set_Point *10 ;
    pdata->blood2_NowTemp = pid_parm_blood2.Now_Point *10 ;
    pdata->blood2_PwmOut = pid_parm_blood2.Out ;
    sum_tmp = pid_parm_blood2.Sum_Error *100;
    if(sum_tmp >= 32767)
        sum_tmp = 32767;
    else if (sum_tmp <= -32768)
        sum_tmp = -32768;
    pdata->blood2_SumErr = sum_tmp ;

    pdata->ehp_SetTemp = pid_parm_ehp.Set_Point *10 ;
    pdata->ehp_NowTemp = pid_parm_ehp.Now_Point *10 ;
    pdata->ehp_PwmOut = pid_parm_ehp.Out ;
    sum_tmp = pid_parm_ehp.Sum_Error *100;
    if(sum_tmp >= 32767)
        sum_tmp = 32767;
    else if (sum_tmp <= -32768)
        sum_tmp = -32768;
    pdata->ehp_SumErr = sum_tmp ;

    pdata->ft_SetTemp = pid_parm_ft.Set_Point *10 ;
    pdata->ft_NowTemp = pid_parm_ft.Now_Point *10 ;
    pdata->ft_PwmOut = pid_parm_ft.Out ;
    sum_tmp = pid_parm_ft.Sum_Error *100;
    if(sum_tmp >= 32767)
        sum_tmp = 32767;
    else if (sum_tmp <= -32768)
        sum_tmp = -32768;
    pdata->ft_SumErr =  sum_tmp;

    pdata->ft2_SetTemp = pid_parm_ft2.Set_Point *10 ;
    pdata->ft2_NowTemp = pid_parm_ft2.Now_Point *10 ;
    pdata->ft2_PwmOut = pid_parm_ft2.Out ;
    sum_tmp = pid_parm_ft2.Sum_Error *100;
    if(sum_tmp >= 32767)
        sum_tmp = 32767;
    else if (sum_tmp <= -32768)
        sum_tmp = -32768;
    pdata->ft2_SumErr = sum_tmp ;


    p_tail->stamp = pack_cnt++;
    p_tail->crc = CRC8_Generator(&p_head->src, data_len + 11);
    p_tail->end = 0x5555;

    if(Net_Get_NET_Mode() != INTER_NET_MODE_OFF) //数据传到网络端
    {
        Net_Data_Package(tx_buf, p_head->len + INTER_COMM_HEAD_LEN + INTER_COMM_TAIL_LEN);
    }
}

